package com.c2b.algorithm.leetcode.base;

/**
 * <a href='https://leetcode.cn/problems/find-the-width-of-columns-of-a-grid/'>查询网格图中每一列的宽度(Find the Width of Columns of a Grid)</a>
 * <p>
 * 给你一个下标从 0 开始的 m x n 整数矩阵 grid 。矩阵中某一列的宽度是这一列数字的最大 字符串长度 。
 *     <ul>
 *         <li>比方说，如果 grid = [[-10], [3], [12]] ，那么唯一一列的宽度是 3 ，因为 -10 的字符串长度为 3 。</li>
 *     </ul>
 *     请你返回一个大小为 n 的整数数组 ans ，其中 ans[i] 是第 i 列的宽度。
 * </p>
 * <p>一个有 len 个数位的整数 x ，如果是非负数，那么 字符串长度 为 len ，否则为 len + 1 。</p>
 *
 * <p>
 * <b>示例：</b>
 * <pre>
 * 示例 1：
 *      输入：grid = [[1],[22],[333]]
 *      输出：[3]
 *      解释：第 0 列中，333 字符串长度为 3 。
 *
 * 示例 2：
 *      输入：grid = [[-15,1,3],[15,7,12],[5,6,-2]]
 *      输出：[3,1,2]
 *      解释：
 *          第 0 列中，只有 -15 字符串长度为 3 。
 *          第 1 列中，所有整数的字符串长度都是 1 。
 *          第 2 列中，12 和 -2 的字符串长度都为 2 。
 * </pre>
 * </p>
 *
 * <p>
 * <b>提示：</b>
 * <ul>
 *     <li>m == grid.length</li>
 *     <li>n == grid[i].length</li>
 *     <li>1 <= m, n <= 100 </li>
 *     <li>-10^9 <= grid[r][c] <= 10^9</li>
 * </ul>
 * </p>
 *
 * @author c2b
 * @since 2024/4/28 9:31
 */
public class LC2639FindTheWidthOfColumnsOfGrid_S {
    static class Solution {
        public int[] findColumnWidth(int[][] grid) {
            int col = grid[0].length;
            int[] ans = new int[col];
            for (int i = 0; i < col; i++) {
                int currColMinValue = Integer.MAX_VALUE;
                int currColMaxValue = Integer.MIN_VALUE;
                for (int[] ints : grid) {
                    if (currColMinValue > ints[i]) {
                        currColMinValue = ints[i];
                    }
                    if (currColMaxValue < ints[i]) {
                        currColMaxValue = ints[i];
                    }
                }
                ans[i] = Math.max(getLen(currColMinValue), getLen(currColMaxValue));
            }
            return ans;
        }

        private int getLen(int num) {
            if (num == 0) {
                return 1;
            }
            int length = 0;
            if (num < 0) {
                length = 1;
                num = -num;
            }
            while (num != 0) {
                num /= 10;
                ++length;
            }
            return length;
        }

        public int[] findColumnWidth2(int[][] grid) {
            int n = grid.length, m = grid[0].length;
            int[] res = new int[m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    int x = grid[i][j];
                    int length = 0;
                    if (x <= 0) {
                        length = 1;
                    }
                    while (x != 0) {
                        length += 1;
                        x /= 10;
                    }
                    res[j] = Math.max(res[j], length);
                }
            }
            return res;
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        Printer.printArrayInt(solution.findColumnWidth(
                new int[][]{
                        {1},
                        {22},
                        {333}
                }
        ));

        Printer.printArrayInt(solution.findColumnWidth(
                new int[][]{
                        {-15, 1, 3},
                        {15, 7, 12},
                        {5, 6, -2}
                }
        ));
    }
}
